// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.tiktok.order.item;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpTiktokOrderItem;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpTiktokOrderItem.class)
@Setter
@Getter
public class TmpTiktokOrderItemSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpTiktokOrderItem".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 订单号(模糊搜索)
   */
  private String orderId;

  /**
   * 订单号 比较(eq)
   */
  private String orderIdEq;
  /**
   * 订单号 比较(neq)
   */
  private String orderIdNeq;
  /**
   * 订单号 比较(gt)
   */
  private String orderIdGt;
  /**
   * 订单号 比较(gte)
   */
  private String orderIdGte;
  /**
   * 订单号 比较(lt)
   */
  private String orderIdLt;
  /**
   * 订单号 比较(lte)
   */
  private String orderIdLte;
  /**
   * 订单号 比较(contains)
   */
  private String orderIdContains;
  /**
   * 订单号 比较(notcontains)
   */
  private String orderIdNotcontains;
  /**
   * 订单号 比较(startswith)
   */
  private String orderIdStartswith;
  /**
   * 订单号 比较(endswith)
   */
  private String orderIdEndswith;
  /**
   * 订单号 比较(isnull)
   */
  private Boolean orderIdIsnull;
  /**
   * 订单号 比较(isnotnull)
   */
  private Boolean orderIdIsnotnull;

  /**
   * 订单号(精确搜索)
   */
  private List<String> orderIdInList;

  /**
   * 行号(模糊搜索)
   */
  private String itemId;

  /**
   * 行号 比较(eq)
   */
  private String itemIdEq;
  /**
   * 行号 比较(neq)
   */
  private String itemIdNeq;
  /**
   * 行号 比较(gt)
   */
  private String itemIdGt;
  /**
   * 行号 比较(gte)
   */
  private String itemIdGte;
  /**
   * 行号 比较(lt)
   */
  private String itemIdLt;
  /**
   * 行号 比较(lte)
   */
  private String itemIdLte;
  /**
   * 行号 比较(contains)
   */
  private String itemIdContains;
  /**
   * 行号 比较(notcontains)
   */
  private String itemIdNotcontains;
  /**
   * 行号 比较(startswith)
   */
  private String itemIdStartswith;
  /**
   * 行号 比较(endswith)
   */
  private String itemIdEndswith;
  /**
   * 行号 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 行号 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;

  /**
   * 行号(精确搜索)
   */
  private List<String> itemIdInList;

  /**
   * SKU ID(模糊搜索)
   */
  private String skuId;

  /**
   * SKU ID 比较(eq)
   */
  private String skuIdEq;
  /**
   * SKU ID 比较(neq)
   */
  private String skuIdNeq;
  /**
   * SKU ID 比较(gt)
   */
  private String skuIdGt;
  /**
   * SKU ID 比较(gte)
   */
  private String skuIdGte;
  /**
   * SKU ID 比较(lt)
   */
  private String skuIdLt;
  /**
   * SKU ID 比较(lte)
   */
  private String skuIdLte;
  /**
   * SKU ID 比较(contains)
   */
  private String skuIdContains;
  /**
   * SKU ID 比较(notcontains)
   */
  private String skuIdNotcontains;
  /**
   * SKU ID 比较(startswith)
   */
  private String skuIdStartswith;
  /**
   * SKU ID 比较(endswith)
   */
  private String skuIdEndswith;
  /**
   * SKU ID 比较(isnull)
   */
  private Boolean skuIdIsnull;
  /**
   * SKU ID 比较(isnotnull)
   */
  private Boolean skuIdIsnotnull;

  /**
   * SKU ID(精确搜索)
   */
  private List<String> skuIdInList;

  /**
   * 状态(模糊搜索)
   */
  private String displayStatus;

  /**
   * 状态 比较(eq)
   */
  private String displayStatusEq;
  /**
   * 状态 比较(neq)
   */
  private String displayStatusNeq;
  /**
   * 状态 比较(gt)
   */
  private String displayStatusGt;
  /**
   * 状态 比较(gte)
   */
  private String displayStatusGte;
  /**
   * 状态 比较(lt)
   */
  private String displayStatusLt;
  /**
   * 状态 比较(lte)
   */
  private String displayStatusLte;
  /**
   * 状态 比较(contains)
   */
  private String displayStatusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String displayStatusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String displayStatusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String displayStatusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean displayStatusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean displayStatusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> displayStatusInList;

  /**
   * 商品id(模糊搜索)
   */
  private String productId;

  /**
   * 商品id 比较(eq)
   */
  private String productIdEq;
  /**
   * 商品id 比较(neq)
   */
  private String productIdNeq;
  /**
   * 商品id 比较(gt)
   */
  private String productIdGt;
  /**
   * 商品id 比较(gte)
   */
  private String productIdGte;
  /**
   * 商品id 比较(lt)
   */
  private String productIdLt;
  /**
   * 商品id 比较(lte)
   */
  private String productIdLte;
  /**
   * 商品id 比较(contains)
   */
  private String productIdContains;
  /**
   * 商品id 比较(notcontains)
   */
  private String productIdNotcontains;
  /**
   * 商品id 比较(startswith)
   */
  private String productIdStartswith;
  /**
   * 商品id 比较(endswith)
   */
  private String productIdEndswith;
  /**
   * 商品id 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 商品id 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;

  /**
   * 商品id(精确搜索)
   */
  private List<String> productIdInList;

  /**
   * 商品名(模糊搜索)
   */
  private String productName;

  /**
   * 商品名 比较(eq)
   */
  private String productNameEq;
  /**
   * 商品名 比较(neq)
   */
  private String productNameNeq;
  /**
   * 商品名 比较(gt)
   */
  private String productNameGt;
  /**
   * 商品名 比较(gte)
   */
  private String productNameGte;
  /**
   * 商品名 比较(lt)
   */
  private String productNameLt;
  /**
   * 商品名 比较(lte)
   */
  private String productNameLte;
  /**
   * 商品名 比较(contains)
   */
  private String productNameContains;
  /**
   * 商品名 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 商品名 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 商品名 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 商品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 商品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 商品名(精确搜索)
   */
  private List<String> productNameInList;

  /**
   * MSKU(模糊搜索)
   */
  private String sellerSku;

  /**
   * MSKU 比较(eq)
   */
  private String sellerSkuEq;
  /**
   * MSKU 比较(neq)
   */
  private String sellerSkuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String sellerSkuGt;
  /**
   * MSKU 比较(gte)
   */
  private String sellerSkuGte;
  /**
   * MSKU 比较(lt)
   */
  private String sellerSkuLt;
  /**
   * MSKU 比较(lte)
   */
  private String sellerSkuLte;
  /**
   * MSKU 比较(contains)
   */
  private String sellerSkuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String sellerSkuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String sellerSkuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String sellerSkuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean sellerSkuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean sellerSkuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> sellerSkuInList;

  /**
   * 商品图片(模糊搜索)
   */
  private String skuImage;

  /**
   * 商品图片 比较(eq)
   */
  private String skuImageEq;
  /**
   * 商品图片 比较(neq)
   */
  private String skuImageNeq;
  /**
   * 商品图片 比较(gt)
   */
  private String skuImageGt;
  /**
   * 商品图片 比较(gte)
   */
  private String skuImageGte;
  /**
   * 商品图片 比较(lt)
   */
  private String skuImageLt;
  /**
   * 商品图片 比较(lte)
   */
  private String skuImageLte;
  /**
   * 商品图片 比较(contains)
   */
  private String skuImageContains;
  /**
   * 商品图片 比较(notcontains)
   */
  private String skuImageNotcontains;
  /**
   * 商品图片 比较(startswith)
   */
  private String skuImageStartswith;
  /**
   * 商品图片 比较(endswith)
   */
  private String skuImageEndswith;
  /**
   * 商品图片 比较(isnull)
   */
  private Boolean skuImageIsnull;
  /**
   * 商品图片 比较(isnotnull)
   */
  private Boolean skuImageIsnotnull;

  /**
   * 商品图片(精确搜索)
   */
  private List<String> skuImageInList;

  /**
   * SKU的名称(模糊搜索)
   */
  private String skuName;

  /**
   * SKU的名称 比较(eq)
   */
  private String skuNameEq;
  /**
   * SKU的名称 比较(neq)
   */
  private String skuNameNeq;
  /**
   * SKU的名称 比较(gt)
   */
  private String skuNameGt;
  /**
   * SKU的名称 比较(gte)
   */
  private String skuNameGte;
  /**
   * SKU的名称 比较(lt)
   */
  private String skuNameLt;
  /**
   * SKU的名称 比较(lte)
   */
  private String skuNameLte;
  /**
   * SKU的名称 比较(contains)
   */
  private String skuNameContains;
  /**
   * SKU的名称 比较(notcontains)
   */
  private String skuNameNotcontains;
  /**
   * SKU的名称 比较(startswith)
   */
  private String skuNameStartswith;
  /**
   * SKU的名称 比较(endswith)
   */
  private String skuNameEndswith;
  /**
   * SKU的名称 比较(isnull)
   */
  private Boolean skuNameIsnull;
  /**
   * SKU的名称 比较(isnotnull)
   */
  private Boolean skuNameIsnotnull;

  /**
   * SKU的名称(精确搜索)
   */
  private List<String> skuNameInList;

  /**
   * 原价
   */
  private java.math.BigDecimal originalPrice;

  /**
   * 最小原价
   */
  private java.math.BigDecimal originalPriceMin;

  /**
   * 最大原价
   */
  private java.math.BigDecimal originalPriceMax;

  /**
   * 原价 比较(eq)
   */
  private java.math.BigDecimal originalPriceEq;
  /**
   * 原价 比较(neq)
   */
  private java.math.BigDecimal originalPriceNeq;
  /**
   * 原价 比较(gt)
   */
  private java.math.BigDecimal originalPriceGt;
  /**
   * 原价 比较(gte)
   */
  private java.math.BigDecimal originalPriceGte;
  /**
   * 原价 比较(lt)
   */
  private java.math.BigDecimal originalPriceLt;
  /**
   * 原价 比较(lte)
   */
  private java.math.BigDecimal originalPriceLte;
  /**
   * 原价 比较(contains)
   */
  private java.math.BigDecimal originalPriceContains;
  /**
   * 原价 比较(notcontains)
   */
  private java.math.BigDecimal originalPriceNotcontains;
  /**
   * 原价 比较(startswith)
   */
  private java.math.BigDecimal originalPriceStartswith;
  /**
   * 原价 比较(endswith)
   */
  private java.math.BigDecimal originalPriceEndswith;
  /**
   * 原价 比较(isnull)
   */
  private Boolean originalPriceIsnull;
  /**
   * 原价 比较(isnotnull)
   */
  private Boolean originalPriceIsnotnull;

  /**
   * 销售价
   */
  private java.math.BigDecimal salePrice;

  /**
   * 最小销售价
   */
  private java.math.BigDecimal salePriceMin;

  /**
   * 最大销售价
   */
  private java.math.BigDecimal salePriceMax;

  /**
   * 销售价 比较(eq)
   */
  private java.math.BigDecimal salePriceEq;
  /**
   * 销售价 比较(neq)
   */
  private java.math.BigDecimal salePriceNeq;
  /**
   * 销售价 比较(gt)
   */
  private java.math.BigDecimal salePriceGt;
  /**
   * 销售价 比较(gte)
   */
  private java.math.BigDecimal salePriceGte;
  /**
   * 销售价 比较(lt)
   */
  private java.math.BigDecimal salePriceLt;
  /**
   * 销售价 比较(lte)
   */
  private java.math.BigDecimal salePriceLte;
  /**
   * 销售价 比较(contains)
   */
  private java.math.BigDecimal salePriceContains;
  /**
   * 销售价 比较(notcontains)
   */
  private java.math.BigDecimal salePriceNotcontains;
  /**
   * 销售价 比较(startswith)
   */
  private java.math.BigDecimal salePriceStartswith;
  /**
   * 销售价 比较(endswith)
   */
  private java.math.BigDecimal salePriceEndswith;
  /**
   * 销售价 比较(isnull)
   */
  private Boolean salePriceIsnull;
  /**
   * 销售价 比较(isnotnull)
   */
  private Boolean salePriceIsnotnull;

  /**
   * 平台折扣金额
   */
  private java.math.BigDecimal platformDiscount;

  /**
   * 最小平台折扣金额
   */
  private java.math.BigDecimal platformDiscountMin;

  /**
   * 最大平台折扣金额
   */
  private java.math.BigDecimal platformDiscountMax;

  /**
   * 平台折扣金额 比较(eq)
   */
  private java.math.BigDecimal platformDiscountEq;
  /**
   * 平台折扣金额 比较(neq)
   */
  private java.math.BigDecimal platformDiscountNeq;
  /**
   * 平台折扣金额 比较(gt)
   */
  private java.math.BigDecimal platformDiscountGt;
  /**
   * 平台折扣金额 比较(gte)
   */
  private java.math.BigDecimal platformDiscountGte;
  /**
   * 平台折扣金额 比较(lt)
   */
  private java.math.BigDecimal platformDiscountLt;
  /**
   * 平台折扣金额 比较(lte)
   */
  private java.math.BigDecimal platformDiscountLte;
  /**
   * 平台折扣金额 比较(contains)
   */
  private java.math.BigDecimal platformDiscountContains;
  /**
   * 平台折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal platformDiscountNotcontains;
  /**
   * 平台折扣金额 比较(startswith)
   */
  private java.math.BigDecimal platformDiscountStartswith;
  /**
   * 平台折扣金额 比较(endswith)
   */
  private java.math.BigDecimal platformDiscountEndswith;
  /**
   * 平台折扣金额 比较(isnull)
   */
  private Boolean platformDiscountIsnull;
  /**
   * 平台折扣金额 比较(isnotnull)
   */
  private Boolean platformDiscountIsnotnull;

  /**
   * 卖家折扣金额
   */
  private java.math.BigDecimal sellerDiscount;

  /**
   * 最小卖家折扣金额
   */
  private java.math.BigDecimal sellerDiscountMin;

  /**
   * 最大卖家折扣金额
   */
  private java.math.BigDecimal sellerDiscountMax;

  /**
   * 卖家折扣金额 比较(eq)
   */
  private java.math.BigDecimal sellerDiscountEq;
  /**
   * 卖家折扣金额 比较(neq)
   */
  private java.math.BigDecimal sellerDiscountNeq;
  /**
   * 卖家折扣金额 比较(gt)
   */
  private java.math.BigDecimal sellerDiscountGt;
  /**
   * 卖家折扣金额 比较(gte)
   */
  private java.math.BigDecimal sellerDiscountGte;
  /**
   * 卖家折扣金额 比较(lt)
   */
  private java.math.BigDecimal sellerDiscountLt;
  /**
   * 卖家折扣金额 比较(lte)
   */
  private java.math.BigDecimal sellerDiscountLte;
  /**
   * 卖家折扣金额 比较(contains)
   */
  private java.math.BigDecimal sellerDiscountContains;
  /**
   * 卖家折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal sellerDiscountNotcontains;
  /**
   * 卖家折扣金额 比较(startswith)
   */
  private java.math.BigDecimal sellerDiscountStartswith;
  /**
   * 卖家折扣金额 比较(endswith)
   */
  private java.math.BigDecimal sellerDiscountEndswith;
  /**
   * 卖家折扣金额 比较(isnull)
   */
  private Boolean sellerDiscountIsnull;
  /**
   * 卖家折扣金额 比较(isnotnull)
   */
  private Boolean sellerDiscountIsnotnull;

  /**
   * 商品类型(模糊搜索)
   */
  private String skuType;

  /**
   * 商品类型 比较(eq)
   */
  private String skuTypeEq;
  /**
   * 商品类型 比较(neq)
   */
  private String skuTypeNeq;
  /**
   * 商品类型 比较(gt)
   */
  private String skuTypeGt;
  /**
   * 商品类型 比较(gte)
   */
  private String skuTypeGte;
  /**
   * 商品类型 比较(lt)
   */
  private String skuTypeLt;
  /**
   * 商品类型 比较(lte)
   */
  private String skuTypeLte;
  /**
   * 商品类型 比较(contains)
   */
  private String skuTypeContains;
  /**
   * 商品类型 比较(notcontains)
   */
  private String skuTypeNotcontains;
  /**
   * 商品类型 比较(startswith)
   */
  private String skuTypeStartswith;
  /**
   * 商品类型 比较(endswith)
   */
  private String skuTypeEndswith;
  /**
   * 商品类型 比较(isnull)
   */
  private Boolean skuTypeIsnull;
  /**
   * 商品类型 比较(isnotnull)
   */
  private Boolean skuTypeIsnotnull;

  /**
   * 商品类型(精确搜索)
   */
  private List<String> skuTypeInList;

  /**
   * 取消原因(模糊搜索)
   */
  private String cancelReason;

  /**
   * 取消原因 比较(eq)
   */
  private String cancelReasonEq;
  /**
   * 取消原因 比较(neq)
   */
  private String cancelReasonNeq;
  /**
   * 取消原因 比较(gt)
   */
  private String cancelReasonGt;
  /**
   * 取消原因 比较(gte)
   */
  private String cancelReasonGte;
  /**
   * 取消原因 比较(lt)
   */
  private String cancelReasonLt;
  /**
   * 取消原因 比较(lte)
   */
  private String cancelReasonLte;
  /**
   * 取消原因 比较(contains)
   */
  private String cancelReasonContains;
  /**
   * 取消原因 比较(notcontains)
   */
  private String cancelReasonNotcontains;
  /**
   * 取消原因 比较(startswith)
   */
  private String cancelReasonStartswith;
  /**
   * 取消原因 比较(endswith)
   */
  private String cancelReasonEndswith;
  /**
   * 取消原因 比较(isnull)
   */
  private Boolean cancelReasonIsnull;
  /**
   * 取消原因 比较(isnotnull)
   */
  private Boolean cancelReasonIsnotnull;

  /**
   * 取消原因(精确搜索)
   */
  private List<String> cancelReasonInList;

  /**
   * 取消方(模糊搜索)
   */
  private String cancelUser;

  /**
   * 取消方 比较(eq)
   */
  private String cancelUserEq;
  /**
   * 取消方 比较(neq)
   */
  private String cancelUserNeq;
  /**
   * 取消方 比较(gt)
   */
  private String cancelUserGt;
  /**
   * 取消方 比较(gte)
   */
  private String cancelUserGte;
  /**
   * 取消方 比较(lt)
   */
  private String cancelUserLt;
  /**
   * 取消方 比较(lte)
   */
  private String cancelUserLte;
  /**
   * 取消方 比较(contains)
   */
  private String cancelUserContains;
  /**
   * 取消方 比较(notcontains)
   */
  private String cancelUserNotcontains;
  /**
   * 取消方 比较(startswith)
   */
  private String cancelUserStartswith;
  /**
   * 取消方 比较(endswith)
   */
  private String cancelUserEndswith;
  /**
   * 取消方 比较(isnull)
   */
  private Boolean cancelUserIsnull;
  /**
   * 取消方 比较(isnotnull)
   */
  private Boolean cancelUserIsnotnull;

  /**
   * 取消方(精确搜索)
   */
  private List<String> cancelUserInList;

  /**
   * 发货时间(模糊搜索)
   */
  private String rtsTime;

  /**
   * 发货时间 比较(eq)
   */
  private String rtsTimeEq;
  /**
   * 发货时间 比较(neq)
   */
  private String rtsTimeNeq;
  /**
   * 发货时间 比较(gt)
   */
  private String rtsTimeGt;
  /**
   * 发货时间 比较(gte)
   */
  private String rtsTimeGte;
  /**
   * 发货时间 比较(lt)
   */
  private String rtsTimeLt;
  /**
   * 发货时间 比较(lte)
   */
  private String rtsTimeLte;
  /**
   * 发货时间 比较(contains)
   */
  private String rtsTimeContains;
  /**
   * 发货时间 比较(notcontains)
   */
  private String rtsTimeNotcontains;
  /**
   * 发货时间 比较(startswith)
   */
  private String rtsTimeStartswith;
  /**
   * 发货时间 比较(endswith)
   */
  private String rtsTimeEndswith;
  /**
   * 发货时间 比较(isnull)
   */
  private Boolean rtsTimeIsnull;
  /**
   * 发货时间 比较(isnotnull)
   */
  private Boolean rtsTimeIsnotnull;

  /**
   * 发货时间(精确搜索)
   */
  private List<String> rtsTimeInList;

  /**
   * 打包状态(模糊搜索)
   */
  private String packageStatus;

  /**
   * 打包状态 比较(eq)
   */
  private String packageStatusEq;
  /**
   * 打包状态 比较(neq)
   */
  private String packageStatusNeq;
  /**
   * 打包状态 比较(gt)
   */
  private String packageStatusGt;
  /**
   * 打包状态 比较(gte)
   */
  private String packageStatusGte;
  /**
   * 打包状态 比较(lt)
   */
  private String packageStatusLt;
  /**
   * 打包状态 比较(lte)
   */
  private String packageStatusLte;
  /**
   * 打包状态 比较(contains)
   */
  private String packageStatusContains;
  /**
   * 打包状态 比较(notcontains)
   */
  private String packageStatusNotcontains;
  /**
   * 打包状态 比较(startswith)
   */
  private String packageStatusStartswith;
  /**
   * 打包状态 比较(endswith)
   */
  private String packageStatusEndswith;
  /**
   * 打包状态 比较(isnull)
   */
  private Boolean packageStatusIsnull;
  /**
   * 打包状态 比较(isnotnull)
   */
  private Boolean packageStatusIsnotnull;

  /**
   * 打包状态(精确搜索)
   */
  private List<String> packageStatusInList;

  /**
   * 货币(模糊搜索)
   */
  private String currency;

  /**
   * 货币 比较(eq)
   */
  private String currencyEq;
  /**
   * 货币 比较(neq)
   */
  private String currencyNeq;
  /**
   * 货币 比较(gt)
   */
  private String currencyGt;
  /**
   * 货币 比较(gte)
   */
  private String currencyGte;
  /**
   * 货币 比较(lt)
   */
  private String currencyLt;
  /**
   * 货币 比较(lte)
   */
  private String currencyLte;
  /**
   * 货币 比较(contains)
   */
  private String currencyContains;
  /**
   * 货币 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 货币 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 货币 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 货币 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 货币 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 货币(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 物流商(模糊搜索)
   */
  private String shippingProviderName;

  /**
   * 物流商 比较(eq)
   */
  private String shippingProviderNameEq;
  /**
   * 物流商 比较(neq)
   */
  private String shippingProviderNameNeq;
  /**
   * 物流商 比较(gt)
   */
  private String shippingProviderNameGt;
  /**
   * 物流商 比较(gte)
   */
  private String shippingProviderNameGte;
  /**
   * 物流商 比较(lt)
   */
  private String shippingProviderNameLt;
  /**
   * 物流商 比较(lte)
   */
  private String shippingProviderNameLte;
  /**
   * 物流商 比较(contains)
   */
  private String shippingProviderNameContains;
  /**
   * 物流商 比较(notcontains)
   */
  private String shippingProviderNameNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private String shippingProviderNameStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private String shippingProviderNameEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean shippingProviderNameIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean shippingProviderNameIsnotnull;

  /**
   * 物流商(精确搜索)
   */
  private List<String> shippingProviderNameInList;

  /**
   * 跟踪号(模糊搜索)
   */
  private String trackingNumber;

  /**
   * 跟踪号 比较(eq)
   */
  private String trackingNumberEq;
  /**
   * 跟踪号 比较(neq)
   */
  private String trackingNumberNeq;
  /**
   * 跟踪号 比较(gt)
   */
  private String trackingNumberGt;
  /**
   * 跟踪号 比较(gte)
   */
  private String trackingNumberGte;
  /**
   * 跟踪号 比较(lt)
   */
  private String trackingNumberLt;
  /**
   * 跟踪号 比较(lte)
   */
  private String trackingNumberLte;
  /**
   * 跟踪号 比较(contains)
   */
  private String trackingNumberContains;
  /**
   * 跟踪号 比较(notcontains)
   */
  private String trackingNumberNotcontains;
  /**
   * 跟踪号 比较(startswith)
   */
  private String trackingNumberStartswith;
  /**
   * 跟踪号 比较(endswith)
   */
  private String trackingNumberEndswith;
  /**
   * 跟踪号 比较(isnull)
   */
  private Boolean trackingNumberIsnull;
  /**
   * 跟踪号 比较(isnotnull)
   */
  private Boolean trackingNumberIsnotnull;

  /**
   * 跟踪号(精确搜索)
   */
  private List<String> trackingNumberInList;

  /**
   * 物流商ID(模糊搜索)
   */
  private String shippingProviderId;

  /**
   * 物流商ID 比较(eq)
   */
  private String shippingProviderIdEq;
  /**
   * 物流商ID 比较(neq)
   */
  private String shippingProviderIdNeq;
  /**
   * 物流商ID 比较(gt)
   */
  private String shippingProviderIdGt;
  /**
   * 物流商ID 比较(gte)
   */
  private String shippingProviderIdGte;
  /**
   * 物流商ID 比较(lt)
   */
  private String shippingProviderIdLt;
  /**
   * 物流商ID 比较(lte)
   */
  private String shippingProviderIdLte;
  /**
   * 物流商ID 比较(contains)
   */
  private String shippingProviderIdContains;
  /**
   * 物流商ID 比较(notcontains)
   */
  private String shippingProviderIdNotcontains;
  /**
   * 物流商ID 比较(startswith)
   */
  private String shippingProviderIdStartswith;
  /**
   * 物流商ID 比较(endswith)
   */
  private String shippingProviderIdEndswith;
  /**
   * 物流商ID 比较(isnull)
   */
  private Boolean shippingProviderIdIsnull;
  /**
   * 物流商ID 比较(isnotnull)
   */
  private Boolean shippingProviderIdIsnotnull;

  /**
   * 物流商ID(精确搜索)
   */
  private List<String> shippingProviderIdInList;

  /**
   * 是否礼品
   */
  private Boolean isGift;

  /**
   * 是否礼品
   */
  private String isGiftEq;

  /**
   * 小订单费
   */
  private java.math.BigDecimal smallOrderFee;

  /**
   * 最小小订单费
   */
  private java.math.BigDecimal smallOrderFeeMin;

  /**
   * 最大小订单费
   */
  private java.math.BigDecimal smallOrderFeeMax;

  /**
   * 小订单费 比较(eq)
   */
  private java.math.BigDecimal smallOrderFeeEq;
  /**
   * 小订单费 比较(neq)
   */
  private java.math.BigDecimal smallOrderFeeNeq;
  /**
   * 小订单费 比较(gt)
   */
  private java.math.BigDecimal smallOrderFeeGt;
  /**
   * 小订单费 比较(gte)
   */
  private java.math.BigDecimal smallOrderFeeGte;
  /**
   * 小订单费 比较(lt)
   */
  private java.math.BigDecimal smallOrderFeeLt;
  /**
   * 小订单费 比较(lte)
   */
  private java.math.BigDecimal smallOrderFeeLte;
  /**
   * 小订单费 比较(contains)
   */
  private java.math.BigDecimal smallOrderFeeContains;
  /**
   * 小订单费 比较(notcontains)
   */
  private java.math.BigDecimal smallOrderFeeNotcontains;
  /**
   * 小订单费 比较(startswith)
   */
  private java.math.BigDecimal smallOrderFeeStartswith;
  /**
   * 小订单费 比较(endswith)
   */
  private java.math.BigDecimal smallOrderFeeEndswith;
  /**
   * 小订单费 比较(isnull)
   */
  private Boolean smallOrderFeeIsnull;
  /**
   * 小订单费 比较(isnotnull)
   */
  private Boolean smallOrderFeeIsnotnull;

  /**
   * 包裹id(模糊搜索)
   */
  private String packageId;

  /**
   * 包裹id 比较(eq)
   */
  private String packageIdEq;
  /**
   * 包裹id 比较(neq)
   */
  private String packageIdNeq;
  /**
   * 包裹id 比较(gt)
   */
  private String packageIdGt;
  /**
   * 包裹id 比较(gte)
   */
  private String packageIdGte;
  /**
   * 包裹id 比较(lt)
   */
  private String packageIdLt;
  /**
   * 包裹id 比较(lte)
   */
  private String packageIdLte;
  /**
   * 包裹id 比较(contains)
   */
  private String packageIdContains;
  /**
   * 包裹id 比较(notcontains)
   */
  private String packageIdNotcontains;
  /**
   * 包裹id 比较(startswith)
   */
  private String packageIdStartswith;
  /**
   * 包裹id 比较(endswith)
   */
  private String packageIdEndswith;
  /**
   * 包裹id 比较(isnull)
   */
  private Boolean packageIdIsnull;
  /**
   * 包裹id 比较(isnotnull)
   */
  private Boolean packageIdIsnotnull;

  /**
   * 包裹id(精确搜索)
   */
  private List<String> packageIdInList;

  /**
   * RDF(零售配送费)
   */
  private java.math.BigDecimal retailDeliveryFee;

  /**
   * 最小RDF(零售配送费)
   */
  private java.math.BigDecimal retailDeliveryFeeMin;

  /**
   * 最大RDF(零售配送费)
   */
  private java.math.BigDecimal retailDeliveryFeeMax;

  /**
   * RDF(零售配送费) 比较(eq)
   */
  private java.math.BigDecimal retailDeliveryFeeEq;
  /**
   * RDF(零售配送费) 比较(neq)
   */
  private java.math.BigDecimal retailDeliveryFeeNeq;
  /**
   * RDF(零售配送费) 比较(gt)
   */
  private java.math.BigDecimal retailDeliveryFeeGt;
  /**
   * RDF(零售配送费) 比较(gte)
   */
  private java.math.BigDecimal retailDeliveryFeeGte;
  /**
   * RDF(零售配送费) 比较(lt)
   */
  private java.math.BigDecimal retailDeliveryFeeLt;
  /**
   * RDF(零售配送费) 比较(lte)
   */
  private java.math.BigDecimal retailDeliveryFeeLte;
  /**
   * RDF(零售配送费) 比较(contains)
   */
  private java.math.BigDecimal retailDeliveryFeeContains;
  /**
   * RDF(零售配送费) 比较(notcontains)
   */
  private java.math.BigDecimal retailDeliveryFeeNotcontains;
  /**
   * RDF(零售配送费) 比较(startswith)
   */
  private java.math.BigDecimal retailDeliveryFeeStartswith;
  /**
   * RDF(零售配送费) 比较(endswith)
   */
  private java.math.BigDecimal retailDeliveryFeeEndswith;
  /**
   * RDF(零售配送费) 比较(isnull)
   */
  private Boolean retailDeliveryFeeIsnull;
  /**
   * RDF(零售配送费) 比较(isnotnull)
   */
  private Boolean retailDeliveryFeeIsnotnull;

  /**
   * 销售税
   */
  private java.math.BigDecimal taxAmount;

  /**
   * 最小销售税
   */
  private java.math.BigDecimal taxAmountMin;

  /**
   * 最大销售税
   */
  private java.math.BigDecimal taxAmountMax;

  /**
   * 销售税 比较(eq)
   */
  private java.math.BigDecimal taxAmountEq;
  /**
   * 销售税 比较(neq)
   */
  private java.math.BigDecimal taxAmountNeq;
  /**
   * 销售税 比较(gt)
   */
  private java.math.BigDecimal taxAmountGt;
  /**
   * 销售税 比较(gte)
   */
  private java.math.BigDecimal taxAmountGte;
  /**
   * 销售税 比较(lt)
   */
  private java.math.BigDecimal taxAmountLt;
  /**
   * 销售税 比较(lte)
   */
  private java.math.BigDecimal taxAmountLte;
  /**
   * 销售税 比较(contains)
   */
  private java.math.BigDecimal taxAmountContains;
  /**
   * 销售税 比较(notcontains)
   */
  private java.math.BigDecimal taxAmountNotcontains;
  /**
   * 销售税 比较(startswith)
   */
  private java.math.BigDecimal taxAmountStartswith;
  /**
   * 销售税 比较(endswith)
   */
  private java.math.BigDecimal taxAmountEndswith;
  /**
   * 销售税 比较(isnull)
   */
  private Boolean taxAmountIsnull;
  /**
   * 销售税 比较(isnotnull)
   */
  private Boolean taxAmountIsnotnull;

  /**
   * 税率
   */
  private java.math.BigDecimal taxRate;

  /**
   * 最小税率
   */
  private java.math.BigDecimal taxRateMin;

  /**
   * 最大税率
   */
  private java.math.BigDecimal taxRateMax;

  /**
   * 税率 比较(eq)
   */
  private java.math.BigDecimal taxRateEq;
  /**
   * 税率 比较(neq)
   */
  private java.math.BigDecimal taxRateNeq;
  /**
   * 税率 比较(gt)
   */
  private java.math.BigDecimal taxRateGt;
  /**
   * 税率 比较(gte)
   */
  private java.math.BigDecimal taxRateGte;
  /**
   * 税率 比较(lt)
   */
  private java.math.BigDecimal taxRateLt;
  /**
   * 税率 比较(lte)
   */
  private java.math.BigDecimal taxRateLte;
  /**
   * 税率 比较(contains)
   */
  private java.math.BigDecimal taxRateContains;
  /**
   * 税率 比较(notcontains)
   */
  private java.math.BigDecimal taxRateNotcontains;
  /**
   * 税率 比较(startswith)
   */
  private java.math.BigDecimal taxRateStartswith;
  /**
   * 税率 比较(endswith)
   */
  private java.math.BigDecimal taxRateEndswith;
  /**
   * 税率 比较(isnull)
   */
  private Boolean taxRateIsnull;
  /**
   * 税率 比较(isnotnull)
   */
  private Boolean taxRateIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
